
#импортируем необходимые библиотеки
!pip install requests

import requests 
import math as mth
import numpy as np
import pandas as pd
import seaborn as sns
import plotly.express as px
from scipy import stats as st
from bs4 import BeautifulSoup 
import plotly.graph_objs as go
from tqdm.notebook import tqdm
import matplotlib.pyplot as plt
from datetime import datetime, timedelta


import warnings
warnings.filterwarnings("ignore")

Requirement already satisfied: requests in c:\users\belle\anaconda3\lib\site-packages (2.27.1)
Requirement already satisfied: idna<4,>=2.5 in c:\users\belle\anaconda3\lib\site-packages (from requests) (3.3)
Requirement already satisfied: charset-normalizer~=2.0.0 in c:\users\belle\anaconda3\lib\site-packages (from requests) (2.0.4)
Requirement already satisfied: urllib3<1.27,>=1.21.1 in c:\users\belle\anaconda3\lib\site-packages (from requests) (1.26.9)
Requirement already satisfied: certifi>=2017.4.17 in c:\users\belle\anaconda3\lib\site-packages (from requests) (2021.10.8)


sources = pd.read_csv('https://code.s3.yandex.net/datasets/mobile_sources.csv') 
session = pd.read_csv('https://code.s3.yandex.net/datasets/mobile_dataset.csv')


#приведем названия столбцов к змеиному регистру
session.columns = session.columns.str.replace('.', '_')


session.head(5)


session.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 74197 entries, 0 to 74196
Data columns (total 3 columns):
 #   Column      Non-Null Count  Dtype 
---  ------      --------------  ----- 
 0   event_time  74197 non-null  object
 1   event_name  74197 non-null  object
 2   user_id     74197 non-null  object
dtypes: object(3)
memory usage: 1.7+ MB


#изменим тип столбца, где отражается время
session['event_time'] = pd.to_datetime(session['event_time'])


print(session.duplicated().sum()) #проверим наличие дубликатов
print(session['event_name'].unique()) #проверим столбец на наличие неявных дубликатов

0
['advert_open' 'tips_show' 'map' 'contacts_show' 'search_4' 'search_5'
 'tips_click' 'photos_show' 'search_1' 'search_2' 'search_3'
 'favorites_add' 'contacts_call' 'search_6' 'search_7' 'show_contacts']


session['event_name'] = session['event_name'].replace('contacts_show', 'show_contacts')


#приведем названия столбцов к змеиному регистру
sources = sources.rename(columns={'userId':'user_id'})


sources.head(5)


sources.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4293 entries, 0 to 4292
Data columns (total 2 columns):
 #   Column   Non-Null Count  Dtype 
---  ------   --------------  ----- 
 0   user_id  4293 non-null   object
 1   source   4293 non-null   object
dtypes: object(2)
memory usage: 67.2+ KB


print(session.duplicated().sum()) #проверим на наличие дубликатоd
print(sources['source'].unique()) #проверим столбец на наличие неявных дубликатов

0
['other' 'yandex' 'google']


#отсортируем датасет по дате и уникальным пользователям
session = session.sort_values(['user_id', 'event_time']) 

# определим нумерацию сессий, значение будет меняться если время между действиями отличается больше, чем на 20 минут
g = (session.groupby('user_id')['event_time'].diff() > pd.Timedelta('20Min')).cumsum()

#присвоим эту нумерацию в столбец `session_id`
session['session_id'] = session.groupby(['user_id', g], sort=False).ngroup() + 1


session.tail(2)


session.head(3)


print(f'В таблице данные с {session["event_time"].min()} по {session["event_time"].max()}')

В таблице данные с 2019-10-07 00:00:00.431357 по 2019-11-03 23:58:12.532487


#построим гистограмму по дате и времени

plt.figure(figsize=(15,5))
session['event_time'].hist(bins=1000, color='#668567')
plt.title('Время активности пользователей в приложении')
plt.xlabel('Дата и время') 
plt.ylabel('Частота')
plt.show()


plt.figure(figsize=(15,12))


plt.subplot(2,1,1)
session['event_time'].hist(bins=1000, color='#668567')
plt.xlim(pd.datetime(2019,10,13), pd.datetime(2019,10,15))
plt.title('Время активности пользователей в приложении с 13 по 15 октября 2019 года')
plt.xlabel('Дата и время') 
plt.ylabel('Частота')

plt.subplot(2,1,2)
session['event_time'].hist(bins=1000, color='#d9e9a9')
plt.xlim(pd.datetime(2019,10,25), pd.datetime(2019,10,27))
plt.title('Время активности пользователей в приложении с 25 по 27 октября 2019 года')
plt.xlabel('Дата и время') 
plt.ylabel('Частота')

plt.show()


#подготовим таблицу для рассчета
retention = session.copy()

#построим сводную таблицу, где найдем время первого посещения
x = retention.pivot_table(index='user_id', values='event_time', aggfunc='first').reset_index()

#переименуем колонки
x.columns=['user_id', 'first']

#объеденим две таблицы
retention = retention.merge(x, on='user_id')

#выделим столбец с датой
retention['dt'] = retention['first'].dt.date

#оставим только одно действие в рамках сессии
retention =retention.loc[~retention['session_id'].duplicated()]


def retention_rate(df, horizon):
    '''
    функция строит таблицу удержания
    
    input: датасет, значение горизонта анализа
    output: таблица удержания пользователей
    '''
    
    # вычисляем лайфтайм для каждой сессии в днях
    df['lifetime'] = (df['event_time'] - df['first']).dt.days

    # строим таблицу удержания
    result_grouped = df.pivot_table(
        index=['dt'],
        columns='lifetime', 
        values='user_id', 
        aggfunc='nunique')

    # вычисляем размеры когорт
    cohort_sizes = (df.groupby('dt').agg({'user_id': 'nunique'})
        .rename(columns={'user_id': 'cohort_size'}))
    

    # объединяем размеры когорт и таблицу удержания
    result_grouped = cohort_sizes.merge(result_grouped, on='dt', how='left').fillna(0)

    # делим данные таблицы удержания на размеры когорт
    result_grouped = result_grouped.div(result_grouped['cohort_size'], axis=0)

    # исключаем из результата все лайфтаймы, превышающие горизонт анализа
    result_grouped = result_grouped[['cohort_size'] + list(range(horizon))]

    result_grouped['cohort_size'] = cohort_sizes

    return result_grouped


#применим фукнцию
rent_r = retention_rate(retention, 15)
rent_r.head()


#построим тепловую карту по удержанию
plt.figure(figsize=(15,5))

sns.heatmap(rent_r.drop('cohort_size', axis=1))
plt.title('Тепловая карта удержания пользователей')
plt.xlabel('Лайфтайм')
plt.ylabel('День первого посещения')
plt.show()


print('Доля пользователей на следующий день')
rent_r[1].describe()

Доля пользователей на следующий день

count    28.000000
mean      0.105909
std       0.032922
min       0.000000
25%       0.088385
50%       0.100929
75%       0.128095
max       0.170370
Name: 1, dtype: float64


print('Доля пользователей через неделю')
rent_r[7].describe()

Доля пользователей через неделю

count    28.000000
mean      0.045373
std       0.031044
min       0.000000
25%       0.018519
50%       0.049511
75%       0.070512
max       0.093168
Name: 7, dtype: float64


print(session['user_id'].nunique(), 'уникальных пользователей')

4293 уникальных пользователей


#количество сессий у каждого пользователя
num_of_visits = session.pivot_table(index='user_id', values='session_id', aggfunc='nunique')

plt.figure(figsize=(15,5))

plt.subplot(1,2,1)
num_of_visits.boxplot('session_id')
plt.title('Количество сессий у пользователей (полный масштаб)')
plt.ylabel('Количество сессий') 

plt.subplot(1,2,2)
num_of_visits.boxplot('session_id')
plt.ylim(0,8)
plt.title('Количество сессий у пользователей(приближенный график)')
plt.ylabel('Количество сессий')

plt.show()


#посмотрим количество совершаемых действий
num_of_event = pd.DataFrame(session['event_name'].value_counts()).reset_index()

#переименуем столбцы
num_of_event.columns=['event', 'count'] 

num_of_event.head(3)


#составим датасет, где только поисковые действия
search = num_of_event[num_of_event['event'].str.contains("search")]

#Удалим все строки с search из начального датасета
num_of_event = num_of_event[~num_of_event.event.str.contains("search")]

#добавим строку search в начальный датасет с общей суммой действий
num_of_event.loc[len(num_of_event.event)] = ['search', search['count'].sum()]

#отсортируем
num_of_event = num_of_event.sort_values(by='count', ascending=False)


plt.figure(figsize=(15,5))
plt.bar(num_of_event['event'], num_of_event['count'], color='#668567')

plt.title('Cуммарное количество событий')
plt.xlabel('Действия пользователей') 
plt.ylabel('Количество')
plt.xticks(rotation=45)
plt.show()


source = sources['source'].value_counts() #датасет с количеством пользователей из каждого источника

plt.figure(figsize=(15,5))

plt.pie(source, autopct='%1.0f%%', colors=('#668567', '#95b88e', '#d9e9a9'), labels=source.index)
plt.title('Количество пользователей по источникам')

plt.show()


asl = session.pivot_table(index='session_id', values='event_time', aggfunc=[min, max]) #сделали сводную таблицу
asl.columns=['time_entrance', 'time_exit'] #переименовали столбцы
asl['duration'] = asl['time_exit'] - asl['time_entrance'] #нашли разницу во времени
asl.sample(3)


print(f'Среднее время пребывания в приложении - {asl["duration"].mean()}, медиана - {asl["duration"].median()}')

Среднее время пребывания в приложении - 0 days 00:10:48.680013362, медиана - 0 days 00:04:55.340814


asl['duration'] = asl['duration'] / np.timedelta64(1, 'm') #продолжительность сессии переведем в минуты и секунды

plt.figure(figsize=(15,5))

plt.subplot(1,2,1)
asl.boxplot('duration')
plt.title('Продолжительность сессий (полный масштаб)')
plt.ylabel('Продолжительность (минуты)') 

plt.subplot(1,2,2)
asl.boxplot('duration')
plt.ylim(0, 20)
plt.title('Продолжительность сессий (приближенный график)')
plt.ylabel('Продолжительность (минуты)')  

plt.show()


#оставим в датасете строки только с действием 'advert_open'
adv_open = session.query('event_name =="advert_open"')

#посчитаем cколько действий совершали в рамках каждой сессии
adv_open = adv_open.pivot_table(index='session_id', values='event_name', aggfunc='count')

print(f'В среднем за сессию пользователь успевает посмотреть {round(adv_open["event_name"].mean(),1)} карточек, медиана - {adv_open["event_name"].median()}')

В среднем за сессию пользователь успевает посмотреть 4.8 карточек, медиана - 3.0


plt.figure(figsize=(16,5))

plt.subplot(1,2,1)
adv_open.boxplot('event_name')
plt.title('Количество просмотренных карточек за сессию (полный масштаб)')
plt.ylabel('Количество карточек') 

plt.subplot(1,2,2)
adv_open.boxplot('event_name')
plt.ylim(0, 12)
plt.title('Количество просмотренных карточек за сессию (приближенный график)')
plt.ylabel('Количество карточек')   

plt.show()


#добавим столбцы, в которых выделим дату посещения и неделю соответсвенно
session['date'] = session['event_time'].dt.date
session['week'] = session['event_time'].dt.week

#для каждого дня и для каждой недели посчитаем сколько было уникальных пользователей
dau = session.pivot_table(index='date', values='user_id', aggfunc='nunique').reset_index()
wau = session.pivot_table(index='week', values='user_id', aggfunc='nunique').reset_index()

#выведем статистику по количеству пользователей за день
dau['user_id'].describe()

count     28.000000
mean     279.178571
std       46.737291
min      178.000000
25%      238.250000
50%      292.500000
75%      310.500000
max      352.000000
Name: user_id, dtype: float64


plt.figure(figsize=(15,5))
plt.bar(dau['date'], dau['user_id'], color='#668567')

plt.title('Количество уникальных пользователей в день')
plt.xlabel('Дата') 
plt.ylabel('Уникальные пользователи')
plt.show()


#в dau переведм поменяем тип столбца с датой
dau['date'] = pd.to_datetime(dau['date'], errors='coerce')

#выделим номер недели
dau['weekday'] = dau['date'].dt.weekday

#добавим столбец. Если день недели равен 5 или 6, то будет значение weekends, в остальных случаях workday
dau['type'] = dau['weekday'].apply ( lambda x: 'weekends' if x in [5,6] else 'workday')


plt.figure(figsize=(15,5))

sns.boxplot(data=dau, x="user_id", y="type", color='#d9e9a9')

plt.title('Количество уникальных пользователей')
plt.xlabel('Количество пользователей')
plt.ylabel('Тип дня')
plt.show()


#выведем статистику по количеству пользователей за день
wau['user_id'].describe()

count       4.000000
mean     1382.500000
std       177.661663
min      1130.000000
25%      1344.500000
50%      1427.000000
75%      1465.000000
max      1546.000000
Name: user_id, dtype: float64


plt.figure(figsize=(15,5))

plt.bar(wau['week'], wau['user_id'], color='#668567')

plt.title('Количество уникальных пользователей в неделю')
plt.xlabel('Номер недели') 
plt.ylabel('Уникальные пользователи')
plt.show()


#выделим номер недели
session['weekday'] = session['event_time'].dt.weekday

display(session.loc[session['event_time'] == session['event_time'].min()])
display(session.loc[session['event_time'] == session['event_time'].max()])


dau = dau['user_id'].median()
wau = wau['user_id'].median()
mau = session['user_id'].nunique()


print ('DAU/WAU = ', "{:.2%}".format(dau/wau))
print ('DAU/MAU = ', "{:.2%}".format(dau/mau))

DAU/WAU =  20.50%
DAU/MAU =  6.81%


session['time_diff'] = session.groupby('session_id')['event_time'].diff()  

#поднимем значения в time_diff на одну ступень выше
session['time_diff'] = session['time_diff'].shift(-1) 
session.head(3)


#выделим отдельным столбцом количество минут
session['time'] = session['time_diff'] / np.timedelta64(1, 's')


#для каждого действия посчитаем сколько времени на нем провели всего
time_event = pd.DataFrame(session.groupby('event_name')['time_diff'].sum()).sort_values(by='time_diff', ascending=False).reset_index()

#для каждого действия посчитаем какая медиана его продолжительности
time_event_median = pd.DataFrame(session.groupby('event_name')['time'].median()).sort_values(by='time', ascending=False).reset_index()


plt.figure(figsize=(15,14))

plt.subplot(2,1,1)
plt.bar(time_event['event_name'], time_event['time_diff'], color='#668567')
plt.xticks(rotation=15)
plt.title('Суммарное количество потраченного времени на каждое действие')
plt.ylabel('Время')
plt.xlabel('Действие')


plt.subplot(2,1,2)
plt.bar(time_event_median['event_name'], time_event_median['time'], color='#d9e9a9')
plt.title('Медиана потраченного времени на каждое действие')
plt.ylabel('Время')
plt.xlabel('Действие')
plt.xticks(rotation=15)


plt.show()


print('Действия, которые пользователь совершает первым делом в приложении ')
pd.DataFrame(session.pivot_table(index = 'session_id', values='event_name', aggfunc='first').value_counts())

Действия, которые пользователь совершает первым делом в приложении


print('Действия, которые пользователь совершает перед выходом из приложения')
pd.DataFrame(session.pivot_table(index = 'session_id', values='event_name', aggfunc='last').value_counts())

Действия, которые пользователь совершает перед выходом из приложения


def myfunc(column):
    """ функция возвращает список уникальных действий

    input: действия пользователя
    output: список уникальных действий пользователя
    """
    return column.unique()


#в рамках сессии выделим уникальные действия
pivot = session.pivot_table(index=['session_id'], values='event_name', aggfunc=myfunc).reset_index() 

#если в стобце толкько одно действие, то поменяем тип на list
pivot['event_name']  = pivot['event_name'].agg(lambda x: x if type(x) !=str  else x.split())

#уберем сценарии, состоящие из одного шага
pivot = pivot[pivot['event_name'].str.len() > 1]

pivot.sample(5)


#добавим столбец с количеством действий в сценарии
pivot['event_count'] = pivot['event_name'].apply( lambda x: len(x))

#запросим информацию по этому столбцу
pivot['event_count'].describe()

count    5337.000000
mean        2.697396
std         0.998715
min         2.000000
25%         2.000000
50%         2.000000
75%         3.000000
max         9.000000
Name: event_count, dtype: float64


session = session[~session[['event_name', 'session_id']].duplicated()]
session.head()


session_1 = session.copy()


def add_features(df):
    
    """ функция возвращает таблицу с новыми столбцами `source`, `targe`, `step` и убирает столбец `event_name`

    input: таблица
    output: таблица с новыми столбцами (источник, целевое действие, номер шага) и без столбца с названием действия
    """
    
    # сортируем по номеру сессии и времени
    sorted_df = df.sort_values(by=['session_id', 'event_time']).copy()
    
    # добавляем шаги событий
    sorted_df['step'] = sorted_df.groupby('session_id').cumcount() + 1
    
    # добавляем узлы-источники и целевые узлы
    # узлы-источники - это сами события
    sorted_df['source'] = sorted_df['event_name']
    
    # добавляем целевые узлы
    sorted_df['target'] = sorted_df.groupby('session_id')['source'].shift(-1)
    
    # возврат таблицы без имени событий
    return sorted_df.drop(['event_name'], axis=1)
  

session = add_features(session)
session.head()


pivot['event_count'].describe()

count    5337.000000
mean        2.697396
std         0.998715
min         2.000000
25%         2.000000
50%         2.000000
75%         3.000000
max         9.000000
Name: event_count, dtype: float64


df_comp = session[session['step'] <= 3].copy().reset_index(drop=True)


def get_source_index(df):
    
    """ функция генерирует индексы столбца `source`

    input: таблица
    output: словарь с индексами, именами и соответсвиями индексов именам `source`
    """
    
    res_dict = {}
    
    count = 0
    # получаем индексы источников
    for no, step in enumerate(df['step'].unique().tolist()):
        # получаем уникальные наименования для шага
        res_dict[no+1] = {}
        res_dict[no+1]['sources'] = df[df['step'] == step]['source'].unique().tolist()
        res_dict[no+1]['sources_index'] = []
        for i in range(len(res_dict[no+1]['sources'])):
            res_dict[no+1]['sources_index'].append(count)
            count += 1
            
    # соединим списки
    for key in res_dict:
        res_dict[key]['sources_dict'] = {}
        for name, no in zip(res_dict[key]['sources'], res_dict[key]['sources_index']):
            res_dict[key]['sources_dict'][name] = no
    return res_dict
  

# создаем словарь
source_indexes = get_source_index(df_comp)


def colors_for_sources(mode='custom'):
    
    """ функция генерирует цвета для диаграммы
    
    input: ничего (запрос на генерацию цветов)
    output: словарь с цветами, соответствующими каждому индексу
    """
    # словарь, в который сложим цвета в соответствии с индексом
    colors_dict = {}
    
            
        # присваиваем ранее подготовленные цвета
    colors = requests.get('https://raw.githubusercontent.com/rusantsovsv/senkey_tutorial/main/json/colors_senkey.json').json()
    for no, label in enumerate(df_comp['source'].unique()):
        colors_dict[label] = colors['custom_colors'][no]
            
    return colors_dict
  
  
# генерируем цвета из списка
colors_dict = colors_for_sources()


def percent_users(sources, targets, values):
    
    """
      функция рассчитывает уникальные id в процентах (для вывода в hover text каждого узла)
    
    input: список с индексами `source`, список с индексами `target`, список с "объемами" потоков `values`
    output: список с "объемами" потоков в процентах
    """
    
    # объединим источники и метки и найдем пары
    zip_lists = list(zip(sources, targets, values))
    
    new_list = []
    
    # подготовим список словарь с общим объемом трафика в узлах
    unique_dict = {}
    
    # проходим по каждому узлу
    for source, target, value in zip_lists:
        if source not in unique_dict:
            # находим все источники и считаем общий трафик
            unique_dict[source] = 0
            for sr, tg, vl in zip_lists:
                if sr == source:
                    unique_dict[source] += vl
                    
    # считаем проценты
    for source, target, value in zip_lists:
        new_list.append(round(100 * value / unique_dict[source], 1))
    
    return new_list


def lists_for_plot(source_indexes=source_indexes, colors=colors_dict, frac=10):
    
    """
    функция создает необходимые переменные списков и возвращает их в виде словаря
    
    input:словарь с именами и индексами source `source_indexes`, словарь с цветами source `colors`, 
        ограничение на минимальный "объем" между узлами `frac`
    output: словарь со списками, необходимыми для диаграммы

    """
    
    sources = []
    targets = []
    values = []
    labels = []
    link_color = []
    link_text = []

    # проходим по каждому шагу
    for step in tqdm(sorted(df_comp['step'].unique()), desc='Шаг'):
        if step + 1 not in source_indexes:
            continue

        # получаем индекс источника
        temp_dict_source = source_indexes[step]['sources_dict']

        # получаем индексы цели
        temp_dict_target = source_indexes[step+1]['sources_dict']

        # проходим по каждой возможной паре, считаем количество таких пар
        for source, index_source in tqdm(temp_dict_source.items()):
            for target, index_target in temp_dict_target.items():
                # делаем срез данных и считаем количество id            
                temp_df = df_comp[(df_comp['step'] == step)&(df_comp['source'] == source)&(df_comp['target'] == target)]
                value = len(temp_df)
                # проверяем минимальный объем потока и добавляем нужные данные
                if value > frac:
                    sources.append(index_source)
                    targets.append(index_target)
                    values.append(value)
                    # делаем поток прозрачным для лучшего отображения
                    link_color.append(colors[source].replace(', 1)', ', 0.2)'))
                    
    labels = []
    colors_labels = []
    for key in source_indexes:
        for name in source_indexes[key]['sources']:
            labels.append(name)
            colors_labels.append(colors[name])
            
    # посчитаем проценты всех потоков
    perc_values = percent_users(sources, targets, values)
    
    # добавим значения процентов для howertext
    link_text = []
    for perc in perc_values:
        link_text.append(f"{perc}%")
    
    # возвратим словарь с вложенными списками
    return {'sources': sources, 
            'targets': targets, 
            'values': values, 
            'labels': labels, 
            'colors_labels': colors_labels, 
            'link_color': link_color, 
            'link_text': link_text}
  

# создаем словарь
data_for_plot = lists_for_plot()

Шаг:   0%|          | 0/3 [00:00<?, ?it/s]

  0%|          | 0/14 [00:00<?, ?it/s]

  0%|          | 0/15 [00:00<?, ?it/s]


def plot_senkey_diagram(data_dict=data_for_plot):    
    
    """
    функция строит диаграмму Сенкей 
    
    input: словарь со списками данных для построения
    output: диаграммы Sankey
    """
    
    fig = go.Figure(data=[go.Sankey(
        domain = dict(
          x =  [0,1],
          y =  [0,1]
        ),
        orientation = "h",
        valueformat = ".0f",
        node = dict(
          pad = 50,
          thickness = 15,
          line = dict(color = "black", width = 0.1),
          label = data_dict['labels'],
          color = data_dict['colors_labels']
        ),
        link = dict(
          source = data_dict['sources'],
          target = data_dict['targets'],
          value = data_dict['values'],
          label = data_dict['link_text'],
          color = data_dict['link_color']
      ))])
    fig.update_layout(title_text="Sankey Diagram", font_size=10, width=800, height=600)
    
    # возвращаем объект диаграммы
    return fig
  

# сохраняем диаграмму в переменную
senkey_diagram = plot_senkey_diagram()
senkey_diagram.show()


pivot.sample(3)


#раскроем список действий
pivot['event_name']  = pivot['event_name'].agg(lambda x: ', '.join(x))

pivot.head(5)


#раскроем список действий
pivot['event_name']  = pivot['event_name'].agg(lambda x: ', '.join(x) if type(x) !=str  else x )

pivot.head(5)


#gосчитаем сколько раз повторяется каждый сценарий
scenario = pd.DataFrame(pivot.groupby('event_name')['session_id'].count()).reset_index() 

#уберем сценарии, в которых нет целевого действия
scenario = scenario.loc[scenario['event_name'].str.contains('show_contacts')]

#уберем сценарии, которые начинаются с целевого дейтсвия (так как задача посмотреть какие действия приводят к целевому действию)
scenario = scenario.loc[~scenario['event_name'].str.startswith('show_contacts')]

#остортируем по убыванию популярности сценариев
scenario = scenario.sort_values(by='session_id', ascending=False).reset_index()

scenario.head(5)


scenario.head(4)


for i in range(4):
    scenario_list = scenario.loc[i, 'event_name'].split(', ') #преобразовывает колонку `event_name` в список действий
    print(f'Воронка по сценарию {" - ".join(scenario_list)}. По такому пути пользователи прошли {scenario["session_id"][i]} раз')

    sp=[] #подготовим пустой список
    
    df = session_1.copy() #запишем в df полную таблицу 
    
    #для каждого действия в сценарии
    for e in scenario_list: 
        
        # в `users` запишем id пользователей, кто совершал это действие
        users = df.query('event_name == @e')['user_id']
        
        # `df` перезапишем и оставим там только тех пользователей, чьи id в переменной `users`
        df = df.query('user_id in @users') 
        
        # количество оставшихся уникальных пользователей запиешем в список
        sp.append(df['user_id'].nunique())

    #построим воронку
    fig = go.Figure(go.Funnel(
    y = scenario_list,
    x =  sp,
    textposition = "inside",
    textinfo = "value+percent initial",
    marker = {"color":'forestgreen'}))
    
    fig.show()

Воронка по сценарию tips_show - show_contacts. По такому пути пользователи прошли 376 раз

Воронка по сценарию map - tips_show - show_contacts. По такому пути пользователи прошли 93 раз

Воронка по сценарию photos_show - show_contacts. По такому пути пользователи прошли 83 раз

Воронка по сценарию search_1 - show_contacts - contacts_call. По такому пути пользователи прошли 52 раз


# создадим список пользователей, которые просмотрели контакты
show_contacts = session_1.query('event_name == "show_contacts"')['user_id'].unique() 

#оставим пользователей, чьи id есть в `show_contacts`
users_sc = session_1.query('user_id in @show_contacts ') 

#оставим пользователей, чьих id нет в `show_contacts`
users_without_sc = session_1.query('user_id not in @show_contacts')


mean, median = [],[]
for e in [users_sc, users_without_sc]:
    #список сессий, в которых есть поиск
    search = e.query('event_name == "search_1"')['session_id'] 

    #список сессий, в которых есть открытие
    adv_open = e.query('event_name == "advert_open"')['session_id']

    #cписок сессий, в рамках которых есть и поиск и открытие объявления
    session_list = list(set(search)&set(adv_open))  

    # оставим строки  только с сессиями из `session_sc`
    df = e.query('session_id in @session_list') 

    #оставим только два действия (поиск и открытие)
    df = df.query('event_name in ["search_1", "advert_open"]') 

    #найдем разницу между действиями в рамках одной сессии
    df['time'] = df.groupby('session_id')['event_time'].diff()

    #посчитаем медианное значение времени
    df_mean = df['time'].mean()
    df_median = df['time'].median()
    
    mean.append(df_mean)
    median.append(df_median)


print('Среднее время поиска', mean)
print('Медиана времени поиска', median)

Среднее время поиска [Timedelta('0 days 00:10:16.597706166'), Timedelta('0 days 00:13:52.897521047')]
Медиана времени поиска [Timedelta('0 days 00:07:27.938930'), Timedelta('0 days 00:10:10.340973')]


print(f'Разница медиан длительности времени между поиском и открытием объявления составляет {median[1] - median[0]}')

Разница медиан длительности времени между поиском и открытием объявления составляет 0 days 00:02:42.402043


def hypothesis_testing(trials, successes):
    
    """
    функция выводит значение p-value и выводы о принятии/отвержении гипотезы
    
    input: список с общим количеством пользователей в каждой из групп,
           список с количеством пользователей, совершивших целевое действие в каждой из групп,
    output: значение p-value и выводы о принятии/отвержении гипотезы
    """
    
    # зададим критический уровень статистической значимости
    alpha = .05 

    # пропорция успехов в первой группе:
    p1 = successes[0]/trials[0]

    # пропорция успехов во второй группе:
    p2 = successes[1]/trials[1]

    # пропорция успехов в комбинированном датасете:
    p_combined = (successes[0] + successes[1]) / (trials[0] + trials[1])

    # разница пропорций в датасетах
    difference = p1 - p2

    # считаем статистику в ст.отклонениях стандартного нормального распределения
    z_value = difference / mth.sqrt(p_combined * (1 - p_combined) * (1/trials[0] + 1/trials[1]))

    # задаем стандартное нормальное распределение (среднее 0, ст.отклонение 1)
    distr = st.norm(0, 1) 

    p_value = (1 - distr.cdf(abs(z_value))) * 2

    print('p-значение: ', p_value)

    #выводим вывод
    if p_value < alpha:
        print('Отвергаем нулевую гипотезу: между долями есть значимая разница')
    else:
        print('Не получилось отвергнуть нулевую гипотезу, нет оснований считать доли разными')


event_for_users = session_1.groupby('user_id')['event_name'].unique().reset_index()
event_for_users['event_name'] = event_for_users['event_name'].agg(lambda x: ' '.join(x))
event_for_users.head(3)


#в `group_1` сохраним id только тех пользователей, кто совершил `tips_show` и `tips_click`
group_1 = event_for_users.loc[event_for_users['event_name'].str.contains("tips_show") & event_for_users['event_name'].str.contains("tips_click")]

#посчитаем количество уникальных пользователей 
gr_1 = group_1['user_id'].nunique()

print(gr_1, 'пользователей в первой группе')

297 пользователей в первой группе


#посчитаем количество уникальных пользователей из группы 1, которые посмотрели контакты
gr_1_sc = group_1.loc[group_1['event_name'].str.contains("show_contacts")]['user_id'].nunique()

print(gr_1_sc, 'пользователей из первой группы посмотрели контакты' )

91 пользователей из первой группы посмотрели контакты


#в `group_2` сохраним id только тех пользователей, кто совершил `tips_show`, но не совершил `tips_click`
group_2 = event_for_users.loc[event_for_users['event_name'].str.contains("tips_show") & ~(event_for_users['event_name'].str.contains("tips_click"))]

#посчитаем количество уникальных пользователей
gr_2 = group_2['user_id'].nunique() 

print(gr_2, 'пользователей во второй группе')

2504 пользователей во второй группе


#посчитаем количество уникальных пользователей из группы 2, которые посмотрели контакты
gr_2_sc = group_2.loc[group_2['event_name'].str.contains("show_contacts")]['user_id'].nunique()

print(gr_2_sc, 'пользователей из второй группы посмотрели контакты')

425 пользователей из второй группы посмотрели контакты


print(f'''
{gr_1} пользователей увидели рекомендованное объявление и перешли по нему.
Из них {gr_1_sc} посмотрели номер телефона.

{gr_2} пользователь увидели рекомендованное объявление, но не перешли по нему.
Из них {gr_2_sc} посмотрели номер телефона.
''')

297 пользователей увидели рекомендованное объявление и перешли по нему.
Из них 91 посмотрели номер телефона.

2504 пользователь увидели рекомендованное объявление, но не перешли по нему.
Из них 425 посмотрели номер телефона.


#передадим полученные значения функции
successes = [gr_1_sc, gr_2_sc]
trials = [gr_1, gr_2]
hypothesis_testing(trials, successes)

p-значение:  9.218316554537864e-09
Отвергаем нулевую гипотезу: между долями есть значимая разница


# создадим список пользователей кто добавлял объявления в избранное
fa = session_1.query('event_name == "favorites_add"')['user_id'] # список пользователей кто добавлял объявления в избранное

# создадим список пользователей кто не добавлял объявления в избранное
nfa = session_1.query('user_id not in @fa')['user_id'] 

#посчитаем количество уникальных пользователей в каждой из групп
fa_count = fa.nunique() 
nfa_count = nfa.nunique() 

print(f'{fa_count} пользователей добавляли объявления в избранное, а {nfa_count} не совершали это действие')

351 пользователей добавляли объявления в избранное, а 3942 не совершали это действие


#датасет с событием "посмотрел контакт"
show_cont = session_1.query('event_name == "show_contacts"') 

#для каждой группы посчитаем сколько пользователей посмотрели контакты
sc_fa = show_cont.query('user_id in @fa')['user_id'].nunique()
sc_nfa = show_cont.query('user_id in @nfa')['user_id'].nunique()

print(f'Из первой группы посмотрели контакты {sc_fa} пользователей, из второй - {sc_nfa}')

Из первой группы посмотрели контакты 136 пользователей, из второй - 845


#передадим полученные значения функции
successes = [sc_fa, sc_nfa]
trials = [fa_count, nfa_count]
hypothesis_testing(trials, successes)

p-значение:  1.3455903058456897e-13
Отвергаем нулевую гипотезу: между долями есть значимая разница


 #объеденим два датафрейма
common = session_1.merge(sources, on='user_id')

common.head(3)


#для каждого источника посчитаем количество уникальных пользователей
source = common.pivot_table(index='source', values='user_id', aggfunc='nunique')

display(source)

#для каждый группы запишем и  выведем значение
yandex = source.loc['yandex', 'user_id']
google = source.loc['google', 'user_id']

print(f'''
Из Yandex установило {yandex} пользователей
Из Google - {google}''')

Из Yandex установило 1934 пользователей
Из Google - 1129


#оставим только строки с действием `show_contacts`
common = common.loc[common['event_name'] == "show_contacts"] 

#подготовим пустой список
successes = []

for e in ['yandex', 'google']:
    
    #оставим в таблице только пользователей из источника
    df = common.query('source == @e') 
    
    #посчитаем количество уникальных пользователей, посмотревших контакты
    successes.append(df['user_id'].nunique())


#оставим только строки с действием `show_contacts`
common = common.loc[common['event_name'] == "show_contacts"] 

#подготовим пустой список
successes = []

for e in ['yandex', 'google']:
    
    #в список добавим пользователей из данного источника, посчитаем их колиество
    successes.append(common.query('source == @e')['user_id'].nunique())
                     
print(f'Контакты посмотрели {successes[0]} пользователей из Yandex и {successes[1]} из Google')

Контакты посмотрели 478 пользователей из Yandex и 275 из Google


#передадим полученные значения функции
successes = successes
trials = [yandex, google]
hypothesis_testing(trials, successes)

p-значение:  0.8244316027993777
Не получилось отвергнуть нулевую гипотезу, нет оснований считать доли разными

	event_time	event_name	user_id	session_id
72688	2019-11-03 16:08:18.202734	tips_show	fffb9e79-b927-4dbb-9b48-7fd09b23a62b	10975
72689	2019-11-03 16:08:25.388712	tips_show	fffb9e79-b927-4dbb-9b48-7fd09b23a62b	10975

	cohort_size	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14
dt
2019-10-07	204	1.0	0.117647	0.093137	0.107843	0.053922	0.034314	0.058824	0.078431	0.053922	0.049020	0.049020	0.034314	0.024510	0.058824	0.049020
2019-10-08	167	1.0	0.161677	0.125749	0.053892	0.041916	0.065868	0.053892	0.071856	0.053892	0.035928	0.059880	0.023952	0.029940	0.029940	0.035928
2019-10-09	176	1.0	0.073864	0.062500	0.056818	0.068182	0.068182	0.056818	0.073864	0.056818	0.034091	0.022727	0.028409	0.034091	0.056818	0.028409
2019-10-10	174	1.0	0.086207	0.103448	0.080460	0.091954	0.080460	0.068966	0.051724	0.080460	0.034483	0.034483	0.051724	0.045977	0.040230	0.034483
2019-10-11	136	1.0	0.088235	0.117647	0.095588	0.088235	0.073529	0.066176	0.044118	0.014706	0.044118	0.036765	0.036765	0.051471	0.029412	0.044118

	time_entrance	time_exit	duration
session_id
3568	2019-10-17 13:34:19.809963	2019-10-17 13:34:19.809963	0 days 00:00:00
5589	2019-10-19 23:08:08.284510	2019-10-19 23:28:39.641573	0 days 00:20:31.357063
3052	2019-10-20 13:52:36.495991	2019-10-20 13:52:42.645102	0 days 00:00:06.149111

	session_id	event_name
10428	10429	[map, tips_show]
5891	5892	[map, tips_show]
7077	7078	[map, show_contacts, tips_show]
1760	1761	[show_contacts, tips_show]
6336	6337	[show_contacts, tips_show]

	event_time	event_name	user_id	session_id	date	week	weekday	time_diff	time
805	2019-10-07 13:39:45.989359	tips_show	0001b1d5-b74a-4cbf-aeb0-7df5947bf349	1	2019-10-07	41	0	0 days 00:00:45.063550	45.063550
6541	2019-10-09 18:33:55.577963	map	0001b1d5-b74a-4cbf-aeb0-7df5947bf349	2	2019-10-09	41	2	0 days 00:01:32.683012	92.683012
6565	2019-10-09 18:40:28.738785	tips_show	0001b1d5-b74a-4cbf-aeb0-7df5947bf349	2	2019-10-09	41	2	0 days 00:01:54.225163	114.225163
36412	2019-10-21 19:52:30.778932	tips_show	0001b1d5-b74a-4cbf-aeb0-7df5947bf349	3	2019-10-21	43	0	0 days 00:00:46.386077	46.386077
36419	2019-10-21 19:53:38.767230	map	0001b1d5-b74a-4cbf-aeb0-7df5947bf349	3	2019-10-21	43	0	0 days 00:01:06.242629	66.242629

Анализ данных сервиса "Ненужные вещи"¶

Цель исследования¶

Предобработка данных ¶

Подготовим столбец `session`¶

Подготовим столбец `sources`¶

Выделим сессии пользователей¶

Исследовательский анализ данных ¶

Исследуем время активности пользователей¶

Исследуем Retention Rate - показатель удержания пользователей¶

Исследуем пользователей¶

Исследуем действия пользователей¶

Исследуем источники, с которых пользователи установливают приложение¶

Исследуем average session length (среднюю длину сессии)¶

Исследуем сколько карточек успевает просмотреть (`advert_open`) пользователь за одну сессию¶

Иccледуем DAU и WAU¶

Исследуем на каких действиях пользователи проводили больше всего времени¶

Основная цель исследования ¶

Построим диаграмму Sankey для визуализации основных сценариев¶

Найдем самые популярные сценарии использования приложения, которые приводят к целевому действию¶

Построим воронки по популярным сценариям¶

Проанализируем как различается время между поиском и открытием объявления у пользователей, совершающих и не совершающих целевое действие (просмотр контакта)¶

Проверка гипотез ¶

Проверим первую гипотезу¶

Проверим вторую гипотезу¶

Проверим третью гипотезу¶

Общий вывод¶

Наблюдения и рекомендации¶

	event_time	event_name	user_id
0	2019-10-07 00:00:00.431357	advert_open	020292ab-89bc-4156-9acf-68bc2783f894
1	2019-10-07 00:00:01.236320	tips_show	020292ab-89bc-4156-9acf-68bc2783f894
2	2019-10-07 00:00:02.245341	tips_show	cf7eda61-9349-469f-ac27-e5b6f5ec475c
3	2019-10-07 00:00:07.039334	tips_show	020292ab-89bc-4156-9acf-68bc2783f894
4	2019-10-07 00:00:56.319813	advert_open	cf7eda61-9349-469f-ac27-e5b6f5ec475c

	user_id	source
0	020292ab-89bc-4156-9acf-68bc2783f894	other
1	cf7eda61-9349-469f-ac27-e5b6f5ec475c	yandex
2	8c356c42-3ba9-4cb6-80b8-3f868d0192c3	yandex
3	d9b06b47-0f36-419b-bbb0-3533e582a6cb	other
4	f32e1e2a-3027-4693-b793-b7b3ff274439	google

	0
event_name
tips_show	4092
photos_show	1775
search_1	1472
map	1325
show_contacts	609
search_4	529
advert_open	449
search_7	169
search_6	143
favorites_add	119
search_5	117
search_3	69
tips_click	56
search_2	51

	0
event_name
tips_show	5681
photos_show	2191
search_1	849
show_contacts	811
map	351
advert_open	333
favorites_add	240
contacts_call	223
search_5	182
tips_click	55
search_3	42
search_4	9
search_6	4
search_7	3
search_2	1

	session_id	event_name	event_count
2196	2197	[search_4, search_5, tips_show]	3
5588	5589	[search_1, photos_show]	2
7713	7714	[search_5, tips_show]	2

	session_id	event_name	event_count
1	2	map, tips_show	2
2	3	tips_show, map	2
3	4	map, tips_show	2
4	5	search_1, photos_show	2
5	6	search_1, photos_show, favorites_add, show_con...	5

	index	event_name	session_id
0	639	tips_show, show_contacts	376
1	151	map, tips_show, show_contacts	93
2	180	photos_show, show_contacts	83
3	217	search_1, show_contacts, contacts_call	52
4	216	search_1, show_contacts	44

	user_id	event_name
0	0001b1d5-b74a-4cbf-aeb0-7df5947bf349	tips_show map
1	00157779-810c-4498-9e05-a1e9e3cedf93	search_1 photos_show favorites_add show_contac...
2	00463033-5717-4bf1-91b4-09183923b9df	photos_show

	event	count
0	tips_show	40055
1	photos_show	10012
2	advert_open	6164

Анализ данных сервиса "Ненужные вещи"¶

Цель исследования¶

Предобработка данных ¶

Подготовим столбец session¶

Подготовим столбец sources¶

Выделим сессии пользователей¶

Исследовательский анализ данных ¶

Исследуем время активности пользователей¶

Исследуем Retention Rate - показатель удержания пользователей¶

Исследуем пользователей¶

Исследуем действия пользователей¶

Исследуем источники, с которых пользователи установливают приложение¶

Исследуем average session length (среднюю длину сессии)¶

Исследуем сколько карточек успевает просмотреть (advert_open) пользователь за одну сессию¶

Иccледуем DAU и WAU¶

Исследуем на каких действиях пользователи проводили больше всего времени¶

Основная цель исследования ¶

Построим диаграмму Sankey для визуализации основных сценариев¶

Найдем самые популярные сценарии использования приложения, которые приводят к целевому действию¶

Построим воронки по популярным сценариям¶

Проанализируем как различается время между поиском и открытием объявления у пользователей, совершающих и не совершающих целевое действие (просмотр контакта)¶

Проверка гипотез ¶

Проверим первую гипотезу¶

Проверим вторую гипотезу¶

Проверим третью гипотезу¶

Общий вывод¶

Наблюдения и рекомендации¶

Подготовим столбец `session`¶

Подготовим столбец `sources`¶

Исследуем сколько карточек успевает просмотреть (`advert_open`) пользователь за одну сессию¶